/***
 * ASM: a very small and fast Java bytecode manipulation framework
 * Copyright (c) 2000-2007 INRIA, France Telecom
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the name of the copyright holders nor the names of its
 *    contributors may be used to endorse or promote products derived from
 *    this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 */
package org.rsbot.loader.asm;

import java.io.IOException;
import java.io.InputStream;

/**
 * A Java class parser to make a {@link ClassVisitor} visit an existing class.
 * This class parses a byte array conforming to the Java class file format and
 * calls the appropriate visit methods of a given class visitor for each field,
 * method and bytecode instruction encountered.
 *
 * @author Eric Bruneton
 * @author Eugene Kuleshov
 */
public class ClassReader {

	/**
	 * True to enable signatures support.
	 */
	static final boolean SIGNATURES = true;

	/**
	 * True to enable annotations support.
	 */
	static final boolean ANNOTATIONS = true;

	/**
	 * True to enable stack map frames support.
	 */
	static final boolean FRAMES = true;

	/**
	 * True to enable bytecode writing support.
	 */
	static final boolean WRITER = true;

	/**
	 * True to enable JSR_W and GOTO_W support.
	 */
	static final boolean RESIZE = true;

	/**
	 * Flag to skip method code. If this class is set <code>CODE</code>
	 * attribute won't be visited. This can be used, for example, to retrieve
	 * annotations for methods and method parameters.
	 */
	public static final int SKIP_CODE = 1;

	/**
	 * Flag to skip the debug information in the class. If this flag is set the
	 * debug information of the class is not visited, i.e. the
	 * {@link MethodVisitor#visitLocalVariable visitLocalVariable} and
	 * {@link MethodVisitor#visitLineNumber visitLineNumber} methods will not be
	 * called.
	 */
	public static final int SKIP_DEBUG = 2;

	/**
	 * Flag to skip the stack map frames in the class. If this flag is set the
	 * stack map frames of the class is not visited, i.e. the
	 * {@link MethodVisitor#visitFrame visitFrame} method will not be called.
	 * This flag is useful when the {@link ClassWriter#COMPUTE_FRAMES} option is
	 * used: it avoids visiting frames that will be ignored and recomputed from
	 * scratch in the class writer.
	 */
	public static final int SKIP_FRAMES = 4;

	/**
	 * Flag to expand the stack map frames. By default stack map frames are
	 * visited in their original format (i.e. "expanded" for classes whose
	 * version is less than V1_6, and "compressed" for the other classes). If
	 * this flag is set, stack map frames are always visited in expanded format
	 * (this option adds a decompression/recompression step in ClassReader and
	 * ClassWriter which degrades performances quite a lot).
	 */
	public static final int EXPAND_FRAMES = 8;

	/**
	 * The class to be parsed. <i>The content of this array must not be
	 * modified. This field is intended for {@link Attribute} sub classes, and
	 * is normally not needed by class generators or adapters.</i>
	 */
	public final byte[] b;

	/**
	 * The start index of each constant pool item in {@link #b b}, plus one.
	 * The one byte offset skips the constant pool item tag that indicates its
	 * type.
	 */
	private final int[] items;

	/**
	 * The String objects corresponding to the CONSTANT_Utf8 items. This cache
	 * avoids multiple parsing of a given CONSTANT_Utf8 constant pool item,
	 * which GREATLY improves performances (by a factor 2 to 3). This caching
	 * strategy could be extended to all constant pool items, but its benefit
	 * would not be so great for these items (because they are much less
	 * expensive to parse than CONSTANT_Utf8 items).
	 */
	private final String[] strings;

	/**
	 * Maximum length of the strings contained in the constant pool of the
	 * class.
	 */
	private final int maxStringLength;

	/**
	 * Start index of the class header information (access, name...) in
	 * {@link #b b}.
	 */
	public final int header;

	// ------------------------------------------------------------------------
	// Constructors
	// ------------------------------------------------------------------------

	/**
	 * Constructs a new {@link ClassReader} object.
	 *
	 * @param b the bytecode of the class to be read.
	 */
	public ClassReader(final byte[] b) {
		this(b, 0, b.length);
	}

	/**
	 * Constructs a new {@link ClassReader} object.
	 *
	 * @param b   the bytecode of the class to be read.
	 * @param off the start offset of the class data.
	 * @param len the length of the class data.
	 */
	public ClassReader(final byte[] b, final int off, final int len) {
		this.b = b;
		// parses the constant pool
		items = new int[readUnsignedShort(off + 8)];
		int n = items.length;
		strings = new String[n];
		int max = 0;
		int index = off + 10;
		for (int i = 1; i < n; ++i) {
			items[i] = index + 1;
			int size;
			switch (b[index]) {
				case ClassWriter.FIELD:
				case ClassWriter.METH:
				case ClassWriter.IMETH:
				case ClassWriter.INT:
				case ClassWriter.FLOAT:
				case ClassWriter.NAME_TYPE:
					size = 5;
					break;
				case ClassWriter.LONG:
				case ClassWriter.DOUBLE:
					size = 9;
					++i;
					break;
				case ClassWriter.UTF8:
					size = 3 + readUnsignedShort(index + 1);
					if (size > max) {
						max = size;
					}
					break;
				// case ClassWriter.CLASS:
				// case ClassWriter.STR:
				default:
					size = 3;
					break;
			}
			index += size;
		}
		maxStringLength = max;
		// the class header information starts just after the constant pool
		header = index;
	}

	/**
	 * Returns the class's access flags (see {@link Opcodes}). This value may
	 * not reflect Deprecated and Synthetic flags when bytecode is before 1.5
	 * and those flags are represented by attributes.
	 *
	 * @return the class access flags
	 * @see ClassVisitor#visit(int, int, String, String, String, String[])
	 */
	public int getAccess() {
		return readUnsignedShort(header);
	}

	/**
	 * Returns the internal name of the class (see
	 * {@link Type#getInternalName() getInternalName}).
	 *
	 * @return the internal class name
	 * @see ClassVisitor#visit(int, int, String, String, String, String[])
	 */
	public String getClassName() {
		return readClass(header + 2, new char[maxStringLength]);
	}

	/**
	 * Returns the internal of name of the super class (see
	 * {@link Type#getInternalName() getInternalName}). For interfaces, the
	 * super class is {@link Object}.
	 *
	 * @return the internal name of super class, or <tt>null</tt> for
	 *         {@link Object} class.
	 * @see ClassVisitor#visit(int, int, String, String, String, String[])
	 */
	public String getSuperName() {
		int n = items[readUnsignedShort(header + 4)];
		return n == 0 ? null : readUTF8(n, new char[maxStringLength]);
	}

	/**
	 * Returns the internal names of the class's interfaces (see
	 * {@link Type#getInternalName() getInternalName}).
	 *
	 * @return the array of internal names for all implemented interfaces or
	 *         <tt>null</tt>.
	 * @see ClassVisitor#visit(int, int, String, String, String, String[])
	 */
	public String[] getInterfaces() {
		int index = header + 6;
		int n = readUnsignedShort(index);
		String[] interfaces = new String[n];
		if (n > 0) {
			char[] buf = new char[maxStringLength];
			for (int i = 0; i < n; ++i) {
				index += 2;
				interfaces[i] = readClass(index, buf);
			}
		}
		return interfaces;
	}

	/**
	 * Copies the constant pool data into the given {@link ClassWriter}. Should
	 * be called before the {@link #accept(ClassVisitor, int)} method.
	 *
	 * @param classWriter the {@link ClassWriter} to copy constant pool into.
	 */
	void copyPool(final ClassWriter classWriter) {
		char[] buf = new char[maxStringLength];
		int ll = items.length;
		Item[] items2 = new Item[ll];
		for (int i = 1; i < ll; i++) {
			int index = items[i];
			int tag = b[index - 1];
			Item item = new Item(i);
			int nameType;
			switch (tag) {
				case ClassWriter.FIELD:
				case ClassWriter.METH:
				case ClassWriter.IMETH:
					nameType = items[readUnsignedShort(index + 2)];
					item.set(tag,
							readClass(index, buf),
							readUTF8(nameType, buf),
							readUTF8(nameType + 2, buf));
					break;

				case ClassWriter.INT:
					item.set(readInt(index));
					break;

				case ClassWriter.FLOAT:
					item.set(Float.intBitsToFloat(readInt(index)));
					break;

				case ClassWriter.NAME_TYPE:
					item.set(tag,
							readUTF8(index, buf),
							readUTF8(index + 2, buf),
							null);
					break;

				case ClassWriter.LONG:
					item.set(readLong(index));
					++i;
					break;

				case ClassWriter.DOUBLE:
					item.set(Double.longBitsToDouble(readLong(index)));
					++i;
					break;

				case ClassWriter.UTF8: {
					String s = strings[i];
					if (s == null) {
						index = items[i];
						s = strings[i] = readUTF(index + 2,
								readUnsignedShort(index),
								buf);
					}
					item.set(tag, s, null, null);
				}
				break;

				// case ClassWriter.STR:
				// case ClassWriter.CLASS:
				default:
					item.set(tag, readUTF8(index, buf), null, null);
					break;
			}

			int index2 = item.hashCode % items2.length;
			item.next = items2[index2];
			items2[index2] = item;
		}

		int off = items[1] - 1;
		classWriter.pool.putByteArray(b, off, header - off);
		classWriter.items = items2;
		classWriter.threshold = (int) (0.75d * ll);
		classWriter.index = ll;
	}

	/**
	 * Constructs a new {@link ClassReader} object.
	 *
	 * @param is an input stream from which to read the class.
	 * @throws IOException if a problem occurs during reading.
	 */
	public ClassReader(final InputStream is) throws IOException {
		this(readClass(is));
	}

	/**
	 * Constructs a new {@link ClassReader} object.
	 *
	 * @param name the fully qualified name of the class to be read.
	 * @throws IOException if an exception occurs during reading.
	 */
	public ClassReader(final String name) throws IOException {
		this(ClassLoader.getSystemResourceAsStream(name.replace('.', '/')
				+ ".class"));
	}

	/**
	 * Reads the bytecode of a class.
	 *
	 * @param is an input stream from which to read the class.
	 * @return the bytecode read from the given input stream.
	 * @throws IOException if a problem occurs during reading.
	 */
	private static byte[] readClass(final InputStream is) throws IOException {
		if (is == null) {
			throw new IOException("Class not found");
		}
		byte[] b = new byte[is.available()];
		int len = 0;
		while (true) {
			int n = is.read(b, len, b.length - len);
			if (n == -1) {
				if (len < b.length) {
					byte[] c = new byte[len];
					System.arraycopy(b, 0, c, 0, len);
					b = c;
				}
				return b;
			}
			len += n;
			if (len == b.length) {
				int last = is.read();
				if (last < 0) {
					return b;
				}
				byte[] c = new byte[b.length + 1000];
				System.arraycopy(b, 0, c, 0, len);
				c[len++] = (byte) last;
				b = c;
			}
		}
	}

	// ------------------------------------------------------------------------
	// Public methods
	// ------------------------------------------------------------------------

	/**
	 * Makes the given visitor visit the Java class of this {@link ClassReader}.
	 * This class is the one specified in the constructor (see
	 * {@link #ClassReader(byte[]) ClassReader}).
	 *
	 * @param classVisitor the visitor that must visit this class.
	 * @param flags		option flags that can be used to modify the default behavior
	 *                     of this class. See {@link #SKIP_DEBUG}, {@link #EXPAND_FRAMES},
	 *                     {@link #SKIP_FRAMES}, {@link #SKIP_CODE}.
	 */
	public void accept(final ClassVisitor classVisitor, final int flags) {
		accept(classVisitor, new Attribute[0], flags);
	}

	/**
	 * Makes the given visitor visit the Java class of this {@link ClassReader}.
	 * This class is the one specified in the constructor (see
	 * {@link #ClassReader(byte[]) ClassReader}).
	 *
	 * @param classVisitor the visitor that must visit this class.
	 * @param attrs		prototypes of the attributes that must be parsed during the
	 *                     visit of the class. Any attribute whose type is not equal to the
	 *                     type of one the prototypes will not be parsed: its byte array
	 *                     value will be passed unchanged to the ClassWriter. <i>This may
	 *                     corrupt it if this value contains references to the constant pool,
	 *                     or has syntactic or semantic links with a class element that has
	 *                     been transformed by a class adapter between the reader and the
	 *                     writer</i>.
	 * @param flags		option flags that can be used to modify the default behavior
	 *                     of this class. See {@link #SKIP_DEBUG}, {@link #EXPAND_FRAMES},
	 *                     {@link #SKIP_FRAMES}, {@link #SKIP_CODE}.
	 */
	public void accept(
			final ClassVisitor classVisitor,
			final Attribute[] attrs,
			final int flags) {
		byte[] b = this.b; // the bytecode array
		char[] c = new char[maxStringLength]; // buffer used to read strings
		int i, j, k; // loop variables
		int u, v, w; // indexes in b
		Attribute attr;

		int access;
		String name;
		String desc;
		String attrName;
		String signature;
		int anns = 0;
		int ianns = 0;
		Attribute cattrs = null;

		// visits the header
		u = header;
		access = readUnsignedShort(u);
		name = readClass(u + 2, c);
		v = items[readUnsignedShort(u + 4)];
		String superClassName = v == 0 ? null : readUTF8(v, c);
		String[] implementedItfs = new String[readUnsignedShort(u + 6)];
		w = 0;
		u += 8;
		for (i = 0; i < implementedItfs.length; ++i) {
			implementedItfs[i] = readClass(u, c);
			u += 2;
		}

		boolean skipCode = (flags & SKIP_CODE) != 0;
		boolean skipDebug = (flags & SKIP_DEBUG) != 0;
		boolean unzip = (flags & EXPAND_FRAMES) != 0;

		// skips fields and methods
		v = u;
		i = readUnsignedShort(v);
		v += 2;
		for (; i > 0; --i) {
			j = readUnsignedShort(v + 6);
			v += 8;
			for (; j > 0; --j) {
				v += 6 + readInt(v + 2);
			}
		}
		i = readUnsignedShort(v);
		v += 2;
		for (; i > 0; --i) {
			j = readUnsignedShort(v + 6);
			v += 8;
			for (; j > 0; --j) {
				v += 6 + readInt(v + 2);
			}
		}
		// reads the class's attributes
		signature = null;
		String sourceFile = null;
		String sourceDebug = null;
		String enclosingOwner = null;
		String enclosingName = null;
		String enclosingDesc = null;

		i = readUnsignedShort(v);
		v += 2;
		for (; i > 0; --i) {
			attrName = readUTF8(v, c);
			// tests are sorted in decreasing frequency order
			// (based on frequencies observed on typical classes)
			if ("SourceFile".equals(attrName)) {
				sourceFile = readUTF8(v + 6, c);
			} else if ("InnerClasses".equals(attrName)) {
				w = v + 6;
			} else if ("EnclosingMethod".equals(attrName)) {
				enclosingOwner = readClass(v + 6, c);
				int item = readUnsignedShort(v + 8);
				if (item != 0) {
					enclosingName = readUTF8(items[item], c);
					enclosingDesc = readUTF8(items[item] + 2, c);
				}
			} else if (SIGNATURES && "Signature".equals(attrName)) {
				signature = readUTF8(v + 6, c);
			} else if (ANNOTATIONS && "RuntimeVisibleAnnotations".equals(attrName)) {
				anns = v + 6;
			} else if ("Deprecated".equals(attrName)) {
				access |= Opcodes.ACC_DEPRECATED;
			} else if ("Synthetic".equals(attrName)) {
				access |= Opcodes.ACC_SYNTHETIC | ClassWriter.ACC_SYNTHETIC_ATTRIBUTE;
			} else if ("SourceDebugExtension".equals(attrName)) {
				int len = readInt(v + 2);
				sourceDebug = readUTF(v + 6, len, new char[len]);
			} else if (ANNOTATIONS && "RuntimeInvisibleAnnotations".equals(attrName)) {
				ianns = v + 6;
			} else {
				attr = readAttribute(attrs,
						attrName,
						v + 6,
						readInt(v + 2),
						c,
						-1,
						null);
				if (attr != null) {
					attr.next = cattrs;
					cattrs = attr;
				}
			}
			v += 6 + readInt(v + 2);
		}
		// calls the visit method
		classVisitor.visit(readInt(4),
				access,
				name,
				signature,
				superClassName,
				implementedItfs);

		// calls the visitSource method
		if (!skipDebug && (sourceFile != null || sourceDebug != null)) {
			classVisitor.visitSource(sourceFile, sourceDebug);
		}

		// calls the visitOuterClass method
		if (enclosingOwner != null) {
			classVisitor.visitOuterClass(enclosingOwner,
					enclosingName,
					enclosingDesc);
		}

		// visits the class annotations
		if (ANNOTATIONS) {
			for (i = 1; i >= 0; --i) {
				v = i == 0 ? ianns : anns;
				if (v != 0) {
					j = readUnsignedShort(v);
					v += 2;
					for (; j > 0; --j) {
						v = readAnnotationValues(v + 2,
								c,
								true,
								classVisitor.visitAnnotation(readUTF8(v, c), i != 0));
					}
				}
			}
		}

		// visits the class attributes
		while (cattrs != null) {
			attr = cattrs.next;
			cattrs.next = null;
			classVisitor.visitAttribute(cattrs);
			cattrs = attr;
		}

		// calls the visitInnerClass method
		if (w != 0) {
			i = readUnsignedShort(w);
			w += 2;
			for (; i > 0; --i) {
				classVisitor.visitInnerClass(readUnsignedShort(w) == 0
						? null
						: readClass(w, c), readUnsignedShort(w + 2) == 0
						? null
						: readClass(w + 2, c), readUnsignedShort(w + 4) == 0
						? null
						: readUTF8(w + 4, c), readUnsignedShort(w + 6));
				w += 8;
			}
		}

		// visits the fields
		i = readUnsignedShort(u);
		u += 2;
		for (; i > 0; --i) {
			access = readUnsignedShort(u);
			name = readUTF8(u + 2, c);
			desc = readUTF8(u + 4, c);
			// visits the field's attributes and looks for a ConstantValue
			// attribute
			int fieldValueItem = 0;
			signature = null;
			anns = 0;
			ianns = 0;
			cattrs = null;

			j = readUnsignedShort(u + 6);
			u += 8;
			for (; j > 0; --j) {
				attrName = readUTF8(u, c);
				// tests are sorted in decreasing frequency order
				// (based on frequencies observed on typical classes)
				if ("ConstantValue".equals(attrName)) {
					fieldValueItem = readUnsignedShort(u + 6);
				} else if (SIGNATURES && "Signature".equals(attrName)) {
					signature = readUTF8(u + 6, c);
				} else if ("Deprecated".equals(attrName)) {
					access |= Opcodes.ACC_DEPRECATED;
				} else if ("Synthetic".equals(attrName)) {
					access |= Opcodes.ACC_SYNTHETIC | ClassWriter.ACC_SYNTHETIC_ATTRIBUTE;
				} else if (ANNOTATIONS && "RuntimeVisibleAnnotations".equals(attrName)) {
					anns = u + 6;
				} else if (ANNOTATIONS && "RuntimeInvisibleAnnotations".equals(attrName)) {
					ianns = u + 6;
				} else {
					attr = readAttribute(attrs,
							attrName,
							u + 6,
							readInt(u + 2),
							c,
							-1,
							null);
					if (attr != null) {
						attr.next = cattrs;
						cattrs = attr;
					}
				}
				u += 6 + readInt(u + 2);
			}
			// visits the field
			FieldVisitor fv = classVisitor.visitField(access,
					name,
					desc,
					signature,
					fieldValueItem == 0 ? null : readConst(fieldValueItem, c));
			// visits the field annotations and attributes
			if (fv != null) {
				if (ANNOTATIONS) {
					for (j = 1; j >= 0; --j) {
						v = j == 0 ? ianns : anns;
						if (v != 0) {
							k = readUnsignedShort(v);
							v += 2;
							for (; k > 0; --k) {
								v = readAnnotationValues(v + 2,
										c,
										true,
										fv.visitAnnotation(readUTF8(v, c), j != 0));
							}
						}
					}
				}
				while (cattrs != null) {
					attr = cattrs.next;
					cattrs.next = null;
					fv.visitAttribute(cattrs);
					cattrs = attr;
				}
				fv.visitEnd();
			}
		}

		// visits the methods
		i = readUnsignedShort(u);
		u += 2;
		for (; i > 0; --i) {
			int u0 = u + 6;
			access = readUnsignedShort(u);
			name = readUTF8(u + 2, c);
			desc = readUTF8(u + 4, c);
			signature = null;
			anns = 0;
			ianns = 0;
			int dann = 0;
			int mpanns = 0;
			int impanns = 0;
			cattrs = null;
			v = 0;
			w = 0;

			// looks for Code and Exceptions attributes
			j = readUnsignedShort(u + 6);
			u += 8;
			for (; j > 0; --j) {
				attrName = readUTF8(u, c);
				int attrSize = readInt(u + 2);
				u += 6;
				// tests are sorted in decreasing frequency order
				// (based on frequencies observed on typical classes)
				if ("Code".equals(attrName)) {
					if (!skipCode) {
						v = u;
					}
				} else if ("Exceptions".equals(attrName)) {
					w = u;
				} else if (SIGNATURES && "Signature".equals(attrName)) {
					signature = readUTF8(u, c);
				} else if ("Deprecated".equals(attrName)) {
					access |= Opcodes.ACC_DEPRECATED;
				} else if (ANNOTATIONS && "RuntimeVisibleAnnotations".equals(attrName)) {
					anns = u;
				} else if (ANNOTATIONS && "AnnotationDefault".equals(attrName)) {
					dann = u;
				} else if ("Synthetic".equals(attrName)) {
					access |= Opcodes.ACC_SYNTHETIC | ClassWriter.ACC_SYNTHETIC_ATTRIBUTE;
				} else if (ANNOTATIONS && "RuntimeInvisibleAnnotations".equals(attrName)) {
					ianns = u;
				} else if (ANNOTATIONS && "RuntimeVisibleParameterAnnotations".equals(attrName)) {
					mpanns = u;
				} else if (ANNOTATIONS && "RuntimeInvisibleParameterAnnotations".equals(attrName)) {
					impanns = u;
				} else {
					attr = readAttribute(attrs,
							attrName,
							u,
							attrSize,
							c,
							-1,
							null);
					if (attr != null) {
						attr.next = cattrs;
						cattrs = attr;
					}
				}
				u += attrSize;
			}
			// reads declared exceptions
			String[] exceptions;
			if (w == 0) {
				exceptions = null;
			} else {
				exceptions = new String[readUnsignedShort(w)];
				w += 2;
				for (j = 0; j < exceptions.length; ++j) {
					exceptions[j] = readClass(w, c);
					w += 2;
				}
			}

			// visits the method's code, if any
			MethodVisitor mv = classVisitor.visitMethod(access,
					name,
					desc,
					signature,
					exceptions);

			if (mv != null) {
				/*
								 * if the returned MethodVisitor is in fact a MethodWriter, it
								 * means there is no method adapter between the reader and the
								 * writer. If, in addition, the writer's constant pool was
								 * copied from this reader (mw.cw.cr == this), and the signature
								 * and exceptions of the method have not been changed, then it
								 * is possible to skip all visit events and just copy the
								 * original code of the method to the writer (the access, name
								 * and descriptor can have been changed, this is not important
								 * since they are not copied as is from the reader).
								 */
				if (WRITER && mv instanceof MethodWriter) {
					MethodWriter mw = (MethodWriter) mv;
					if (mw.cw.cr == this) {
						if (signature == mw.signature) {
							boolean sameExceptions = false;
							if (exceptions == null) {
								sameExceptions = mw.exceptionCount == 0;
							} else {
								if (exceptions.length == mw.exceptionCount) {
									sameExceptions = true;
									for (j = exceptions.length - 1; j >= 0; --j) {
										w -= 2;
										if (mw.exceptions[j] != readUnsignedShort(w)) {
											sameExceptions = false;
											break;
										}
									}
								}
							}
							if (sameExceptions) {
								/*
																 * we do not copy directly the code into
																 * MethodWriter to save a byte array copy
																 * operation. The real copy will be done in
																 * ClassWriter.toByteArray().
																 */
								mw.classReaderOffset = u0;
								mw.classReaderLength = u - u0;
								continue;
							}
						}
					}
				}

				if (ANNOTATIONS && dann != 0) {
					AnnotationVisitor dv = mv.visitAnnotationDefault();
					readAnnotationValue(dann, c, null, dv);
					if (dv != null) {
						dv.visitEnd();
					}
				}
				if (ANNOTATIONS) {
					for (j = 1; j >= 0; --j) {
						w = j == 0 ? ianns : anns;
						if (w != 0) {
							k = readUnsignedShort(w);
							w += 2;
							for (; k > 0; --k) {
								w = readAnnotationValues(w + 2,
										c,
										true,
										mv.visitAnnotation(readUTF8(w, c), j != 0));
							}
						}
					}
				}
				if (ANNOTATIONS && mpanns != 0) {
					readParameterAnnotations(mpanns, desc, c, true, mv);
				}
				if (ANNOTATIONS && impanns != 0) {
					readParameterAnnotations(impanns, desc, c, false, mv);
				}
				while (cattrs != null) {
					attr = cattrs.next;
					cattrs.next = null;
					mv.visitAttribute(cattrs);
					cattrs = attr;
				}
			}

			if (mv != null && v != 0) {
				int maxStack = readUnsignedShort(v);
				int maxLocals = readUnsignedShort(v + 2);
				int codeLength = readInt(v + 4);
				v += 8;

				int codeStart = v;
				int codeEnd = v + codeLength;

				mv.visitCode();

				// 1st phase: finds the labels
				int label;
				Label[] labels = new Label[codeLength + 2];
				readLabel(codeLength + 1, labels);
				while (v < codeEnd) {
					w = v - codeStart;
					int opcode = b[v] & 0xFF;
					switch (ClassWriter.TYPE[opcode]) {
						case ClassWriter.NOARG_INSN:
						case ClassWriter.IMPLVAR_INSN:
							v += 1;
							break;
						case ClassWriter.LABEL_INSN:
							readLabel(w + readShort(v + 1), labels);
							v += 3;
							break;
						case ClassWriter.LABELW_INSN:
							readLabel(w + readInt(v + 1), labels);
							v += 5;
							break;
						case ClassWriter.WIDE_INSN:
							opcode = b[v + 1] & 0xFF;
							if (opcode == Opcodes.IINC) {
								v += 6;
							} else {
								v += 4;
							}
							break;
						case ClassWriter.TABL_INSN:
							// skips 0 to 3 padding bytes*
							v = v + 4 - (w & 3);
							// reads instruction
							readLabel(w + readInt(v), labels);
							j = readInt(v + 8) - readInt(v + 4) + 1;
							v += 12;
							for (; j > 0; --j) {
								readLabel(w + readInt(v), labels);
								v += 4;
							}
							break;
						case ClassWriter.LOOK_INSN:
							// skips 0 to 3 padding bytes*
							v = v + 4 - (w & 3);
							// reads instruction
							readLabel(w + readInt(v), labels);
							j = readInt(v + 4);
							v += 8;
							for (; j > 0; --j) {
								readLabel(w + readInt(v + 4), labels);
								v += 8;
							}
							break;
						case ClassWriter.VAR_INSN:
						case ClassWriter.SBYTE_INSN:
						case ClassWriter.LDC_INSN:
							v += 2;
							break;
						case ClassWriter.SHORT_INSN:
						case ClassWriter.LDCW_INSN:
						case ClassWriter.FIELDORMETH_INSN:
						case ClassWriter.TYPE_INSN:
						case ClassWriter.IINC_INSN:
							v += 3;
							break;
						case ClassWriter.ITFDYNMETH_INSN:
							v += 5;
							break;
						// case MANA_INSN:
						default:
							v += 4;
							break;
					}
				}
				// parses the try catch entries
				j = readUnsignedShort(v);
				v += 2;
				for (; j > 0; --j) {
					Label start = readLabel(readUnsignedShort(v), labels);
					Label end = readLabel(readUnsignedShort(v + 2), labels);
					Label handler = readLabel(readUnsignedShort(v + 4), labels);
					int type = readUnsignedShort(v + 6);
					if (type == 0) {
						mv.visitTryCatchBlock(start, end, handler, null);
					} else {
						mv.visitTryCatchBlock(start,
								end,
								handler,
								readUTF8(items[type], c));
					}
					v += 8;
				}
				// parses the local variable, line number tables, and code
				// attributes
				int varTable = 0;
				int varTypeTable = 0;
				int stackMap = 0;
				int stackMapSize = 0;
				int frameCount = 0;
				int frameMode = 0;
				int frameOffset = 0;
				int frameLocalCount = 0;
				int frameLocalDiff = 0;
				int frameStackCount = 0;
				Object[] frameLocal = null;
				Object[] frameStack = null;
				boolean zip = true;
				cattrs = null;
				j = readUnsignedShort(v);
				v += 2;
				for (; j > 0; --j) {
					attrName = readUTF8(v, c);
					if ("LocalVariableTable".equals(attrName)) {
						if (!skipDebug) {
							varTable = v + 6;
							k = readUnsignedShort(v + 6);
							w = v + 8;
							for (; k > 0; --k) {
								label = readUnsignedShort(w);
								if (labels[label] == null) {
									readLabel(label, labels).status |= Label.DEBUG;
								}
								label += readUnsignedShort(w + 2);
								if (labels[label] == null) {
									readLabel(label, labels).status |= Label.DEBUG;
								}
								w += 10;
							}
						}
					} else if ("LocalVariableTypeTable".equals(attrName)) {
						varTypeTable = v + 6;
					} else if ("LineNumberTable".equals(attrName)) {
						if (!skipDebug) {
							k = readUnsignedShort(v + 6);
							w = v + 8;
							for (; k > 0; --k) {
								label = readUnsignedShort(w);
								if (labels[label] == null) {
									readLabel(label, labels).status |= Label.DEBUG;
								}
								labels[label].line = readUnsignedShort(w + 2);
								w += 4;
							}
						}
					} else if (FRAMES && "StackMapTable".equals(attrName)) {
						if ((flags & SKIP_FRAMES) == 0) {
							stackMap = v + 8;
							stackMapSize = readInt(v + 2);
							frameCount = readUnsignedShort(v + 6);
						}
						/*
												 * here we do not extract the labels corresponding to
												 * the attribute content. This would require a full
												 * parsing of the attribute, which would need to be
												 * repeated in the second phase (see below). Instead the
												 * content of the attribute is read one frame at a time
												 * (i.e. after a frame has been visited, the next frame
												 * is read), and the labels it contains are also
												 * extracted one frame at a time. Thanks to the ordering
												 * of frames, having only a "one frame lookahead" is not
												 * a problem, i.e. it is not possible to see an offset
												 * smaller than the offset of the current insn and for
												 * which no Label exist.
												 */
						/*
												 * This is not true for UNINITIALIZED type offsets. We
												 * solve this by parsing the stack map table without a
												 * full decoding (see below).
												 */
					} else if (FRAMES && "StackMap".equals(attrName)) {
						if ((flags & SKIP_FRAMES) == 0) {
							stackMap = v + 8;
							stackMapSize = readInt(v + 2);
							frameCount = readUnsignedShort(v + 6);
							zip = false;
						}
						/*
												 * IMPORTANT! here we assume that the frames are
												 * ordered, as in the StackMapTable attribute, although
												 * this is not guaranteed by the attribute format.
												 */
					} else {
						for (k = 0; k < attrs.length; ++k) {
							if (attrs[k].type.equals(attrName)) {
								attr = attrs[k].read(this,
										v + 6,
										readInt(v + 2),
										c,
										codeStart - 8,
										labels);
								if (attr != null) {
									attr.next = cattrs;
									cattrs = attr;
								}
							}
						}
					}
					v += 6 + readInt(v + 2);
				}

				// 2nd phase: visits each instruction
				if (FRAMES && stackMap != 0) {
					// creates the very first (implicit) frame from the method
					// descriptor
					frameLocal = new Object[maxLocals];
					frameStack = new Object[maxStack];
					if (unzip) {
						int local = 0;
						if ((access & Opcodes.ACC_STATIC) == 0) {
							if ("<init>".equals(name)) {
								frameLocal[local++] = Opcodes.UNINITIALIZED_THIS;
							} else {
								frameLocal[local++] = readClass(header + 2, c);
							}
						}
						j = 1;
						loop:
						while (true) {
							k = j;
							switch (desc.charAt(j++)) {
								case 'Z':
								case 'C':
								case 'B':
								case 'S':
								case 'I':
									frameLocal[local++] = Opcodes.INTEGER;
									break;
								case 'F':
									frameLocal[local++] = Opcodes.FLOAT;
									break;
								case 'J':
									frameLocal[local++] = Opcodes.LONG;
									break;
								case 'D':
									frameLocal[local++] = Opcodes.DOUBLE;
									break;
								case '[':
									while (desc.charAt(j) == '[') {
										++j;
									}
									if (desc.charAt(j) == 'L') {
										++j;
										while (desc.charAt(j) != ';') {
											++j;
										}
									}
									frameLocal[local++] = desc.substring(k, ++j);
									break;
								case 'L':
									while (desc.charAt(j) != ';') {
										++j;
									}
									frameLocal[local++] = desc.substring(k + 1,
											j++);
									break;
								default:
									break loop;
							}
						}
						frameLocalCount = local;
					}
					/*
										 * for the first explicit frame the offset is not
										 * offset_delta + 1 but only offset_delta; setting the
										 * implicit frame offset to -1 allow the use of the
										 * "offset_delta + 1" rule in all cases
										 */
					frameOffset = -1;
					/*
										 * Finds labels for UNINITIALIZED frame types. Instead of
										 * decoding each element of the stack map table, we look
										 * for 3 consecutive bytes that "look like" an UNINITIALIZED
										 * type (tag 8, offset within code bounds, NEW instruction
										 * at this offset). We may find false positives (i.e. not
										 * real UNINITIALIZED types), but this should be rare, and
										 * the only consequence will be the creation of an unneeded
										 * label. This is better than creating a label for each NEW
										 * instruction, and faster than fully decoding the whole
										 * stack map table.
										 */
					for (j = stackMap; j < stackMap + stackMapSize - 2; ++j) {
						if (b[j] == 8) { // UNINITIALIZED FRAME TYPE
							k = readUnsignedShort(j + 1);
							if (k >= 0 && k < codeLength) { // potential offset
								if ((b[codeStart + k] & 0xFF) == Opcodes.NEW) { // NEW at this offset
									readLabel(k, labels);
								}
							}
						}
					}
				}
				v = codeStart;
				Label l;
				while (v < codeEnd) {
					w = v - codeStart;

					l = labels[w];
					if (l != null) {
						mv.visitLabel(l);
						if (!skipDebug && l.line > 0) {
							mv.visitLineNumber(l.line, l);
						}
					}

					while (FRAMES && frameLocal != null
							&& (frameOffset == w || frameOffset == -1)) {
						// if there is a frame for this offset,
						// makes the visitor visit it,
						// and reads the next frame if there is one.
						if (!zip || unzip) {
							mv.visitFrame(Opcodes.F_NEW,
									frameLocalCount,
									frameLocal,
									frameStackCount,
									frameStack);
						} else if (frameOffset != -1) {
							mv.visitFrame(frameMode,
									frameLocalDiff,
									frameLocal,
									frameStackCount,
									frameStack);
						}

						if (frameCount > 0) {
							int tag, delta, n;
							if (zip) {
								tag = b[stackMap++] & 0xFF;
							} else {
								tag = MethodWriter.FULL_FRAME;
								frameOffset = -1;
							}
							frameLocalDiff = 0;
							if (tag < MethodWriter.SAME_LOCALS_1_STACK_ITEM_FRAME) {
								delta = tag;
								frameMode = Opcodes.F_SAME;
								frameStackCount = 0;
							} else if (tag < MethodWriter.RESERVED) {
								delta = tag
										- MethodWriter.SAME_LOCALS_1_STACK_ITEM_FRAME;
								stackMap = readFrameType(frameStack,
										0,
										stackMap,
										c,
										labels);
								frameMode = Opcodes.F_SAME1;
								frameStackCount = 1;
							} else {
								delta = readUnsignedShort(stackMap);
								stackMap += 2;
								if (tag == MethodWriter.SAME_LOCALS_1_STACK_ITEM_FRAME_EXTENDED) {
									stackMap = readFrameType(frameStack,
											0,
											stackMap,
											c,
											labels);
									frameMode = Opcodes.F_SAME1;
									frameStackCount = 1;
								} else if (tag >= MethodWriter.CHOP_FRAME
										&& tag < MethodWriter.SAME_FRAME_EXTENDED) {
									frameMode = Opcodes.F_CHOP;
									frameLocalDiff = MethodWriter.SAME_FRAME_EXTENDED
											- tag;
									frameLocalCount -= frameLocalDiff;
									frameStackCount = 0;
								} else if (tag == MethodWriter.SAME_FRAME_EXTENDED) {
									frameMode = Opcodes.F_SAME;
									frameStackCount = 0;
								} else if (tag < MethodWriter.FULL_FRAME) {
									j = unzip ? frameLocalCount : 0;
									for (k = tag
											- MethodWriter.SAME_FRAME_EXTENDED; k > 0; k--) {
										stackMap = readFrameType(frameLocal,
												j++,
												stackMap,
												c,
												labels);
									}
									frameMode = Opcodes.F_APPEND;
									frameLocalDiff = tag
											- MethodWriter.SAME_FRAME_EXTENDED;
									frameLocalCount += frameLocalDiff;
									frameStackCount = 0;
								} else { // if (tag == FULL_FRAME) {
									frameMode = Opcodes.F_FULL;
									n = frameLocalDiff = frameLocalCount = readUnsignedShort(stackMap);
									stackMap += 2;
									for (j = 0; n > 0; n--) {
										stackMap = readFrameType(frameLocal,
												j++,
												stackMap,
												c,
												labels);
									}
									n = frameStackCount = readUnsignedShort(stackMap);
									stackMap += 2;
									for (j = 0; n > 0; n--) {
										stackMap = readFrameType(frameStack,
												j++,
												stackMap,
												c,
												labels);
									}
								}
							}
							frameOffset += delta + 1;
							readLabel(frameOffset, labels);

							--frameCount;
						} else {
							frameLocal = null;
						}
					}

					int opcode = b[v] & 0xFF;
					switch (ClassWriter.TYPE[opcode]) {
						case ClassWriter.NOARG_INSN:
							mv.visitInsn(opcode);
							v += 1;
							break;
						case ClassWriter.IMPLVAR_INSN:
							if (opcode > Opcodes.ISTORE) {
								opcode -= 59; // ISTORE_0
								mv.visitVarInsn(Opcodes.ISTORE + (opcode >> 2),
										opcode & 0x3);
							} else {
								opcode -= 26; // ILOAD_0
								mv.visitVarInsn(Opcodes.ILOAD + (opcode >> 2),
										opcode & 0x3);
							}
							v += 1;
							break;
						case ClassWriter.LABEL_INSN:
							mv.visitJumpInsn(opcode, labels[w
									+ readShort(v + 1)]);
							v += 3;
							break;
						case ClassWriter.LABELW_INSN:
							mv.visitJumpInsn(opcode - 33, labels[w
									+ readInt(v + 1)]);
							v += 5;
							break;
						case ClassWriter.WIDE_INSN:
							opcode = b[v + 1] & 0xFF;
							if (opcode == Opcodes.IINC) {
								mv.visitIincInsn(readUnsignedShort(v + 2),
										readShort(v + 4));
								v += 6;
							} else {
								mv.visitVarInsn(opcode,
										readUnsignedShort(v + 2));
								v += 4;
							}
							break;
						case ClassWriter.TABL_INSN:
							// skips 0 to 3 padding bytes
							v = v + 4 - (w & 3);
							// reads instruction
							label = w + readInt(v);
							int min = readInt(v + 4);
							int max = readInt(v + 8);
							v += 12;
							Label[] table = new Label[max - min + 1];
							for (j = 0; j < table.length; ++j) {
								table[j] = labels[w + readInt(v)];
								v += 4;
							}
							mv.visitTableSwitchInsn(min,
									max,
									labels[label],
									table);
							break;
						case ClassWriter.LOOK_INSN:
							// skips 0 to 3 padding bytes
							v = v + 4 - (w & 3);
							// reads instruction
							label = w + readInt(v);
							j = readInt(v + 4);
							v += 8;
							int[] keys = new int[j];
							Label[] values = new Label[j];
							for (j = 0; j < keys.length; ++j) {
								keys[j] = readInt(v);
								values[j] = labels[w + readInt(v + 4)];
								v += 8;
							}
							mv.visitLookupSwitchInsn(labels[label],
									keys,
									values);
							break;
						case ClassWriter.VAR_INSN:
							mv.visitVarInsn(opcode, b[v + 1] & 0xFF);
							v += 2;
							break;
						case ClassWriter.SBYTE_INSN:
							mv.visitIntInsn(opcode, b[v + 1]);
							v += 2;
							break;
						case ClassWriter.SHORT_INSN:
							mv.visitIntInsn(opcode, readShort(v + 1));
							v += 3;
							break;
						case ClassWriter.LDC_INSN:
							mv.visitLdcInsn(readConst(b[v + 1] & 0xFF, c));
							v += 2;
							break;
						case ClassWriter.LDCW_INSN:
							mv.visitLdcInsn(readConst(readUnsignedShort(v + 1),
									c));
							v += 3;
							break;
						case ClassWriter.FIELDORMETH_INSN:
						case ClassWriter.ITFDYNMETH_INSN:
							int cpIndex = items[readUnsignedShort(v + 1)];
							String iowner;
							// INVOKEDYNAMIC is receiverless
							if (opcode == Opcodes.INVOKEDYNAMIC) {
								iowner = Opcodes.INVOKEDYNAMIC_OWNER;
							} else {
								iowner = readClass(cpIndex, c);
								cpIndex = items[readUnsignedShort(cpIndex + 2)];
							}
							String iname = readUTF8(cpIndex, c);
							String idesc = readUTF8(cpIndex + 2, c);
							if (opcode < Opcodes.INVOKEVIRTUAL) {
								mv.visitFieldInsn(opcode, iowner, iname, idesc);
							} else {
								mv.visitMethodInsn(opcode, iowner, iname, idesc);
							}
							if (opcode == Opcodes.INVOKEINTERFACE || opcode == Opcodes.INVOKEDYNAMIC) {
								v += 5;
							} else {
								v += 3;
							}
							break;
						case ClassWriter.TYPE_INSN:
							mv.visitTypeInsn(opcode, readClass(v + 1, c));
							v += 3;
							break;
						case ClassWriter.IINC_INSN:
							mv.visitIincInsn(b[v + 1] & 0xFF, b[v + 2]);
							v += 3;
							break;
						// case MANA_INSN:
						default:
							mv.visitMultiANewArrayInsn(readClass(v + 1, c),
									b[v + 3] & 0xFF);
							v += 4;
							break;
					}
				}
				l = labels[codeEnd - codeStart];
				if (l != null) {
					mv.visitLabel(l);
				}
				// visits the local variable tables
				if (!skipDebug && varTable != 0) {
					int[] typeTable = null;
					if (varTypeTable != 0) {
						k = readUnsignedShort(varTypeTable) * 3;
						w = varTypeTable + 2;
						typeTable = new int[k];
						while (k > 0) {
							typeTable[--k] = w + 6; // signature
							typeTable[--k] = readUnsignedShort(w + 8); // index
							typeTable[--k] = readUnsignedShort(w); // start
							w += 10;
						}
					}
					k = readUnsignedShort(varTable);
					w = varTable + 2;
					for (; k > 0; --k) {
						int start = readUnsignedShort(w);
						int length = readUnsignedShort(w + 2);
						int index = readUnsignedShort(w + 8);
						String vsignature = null;
						if (typeTable != null) {
							for (int a = 0; a < typeTable.length; a += 3) {
								if (typeTable[a] == start
										&& typeTable[a + 1] == index) {
									vsignature = readUTF8(typeTable[a + 2], c);
									break;
								}
							}
						}
						mv.visitLocalVariable(readUTF8(w + 4, c),
								readUTF8(w + 6, c),
								vsignature,
								labels[start],
								labels[start + length],
								index);
						w += 10;
					}
				}
				// visits the other attributes
				while (cattrs != null) {
					attr = cattrs.next;
					cattrs.next = null;
					mv.visitAttribute(cattrs);
					cattrs = attr;
				}
				// visits the max stack and max locals values
				mv.visitMaxs(maxStack, maxLocals);
			}

			if (mv != null) {
				mv.visitEnd();
			}
		}

		// visits the end of the class
		classVisitor.visitEnd();
	}

	/**
	 * Reads parameter annotations and makes the given visitor visit them.
	 *
	 * @param v	   start offset in {@link #b b} of the annotations to be read.
	 * @param desc	the method descriptor.
	 * @param buf	 buffer to be used to call {@link #readUTF8 readUTF8},
	 *                {@link #readClass(int, char[]) readClass} or
	 *                {@link #readConst readConst}.
	 * @param visible <tt>true</tt> if the annotations to be read are visible
	 *                at runtime.
	 * @param mv	  the visitor that must visit the annotations.
	 */
	private void readParameterAnnotations(
			int v,
			final String desc,
			final char[] buf,
			final boolean visible,
			final MethodVisitor mv) {
		int i;
		int n = b[v++] & 0xFF;
		// workaround for a bug in javac (javac compiler generates a parameter
		// annotation array whose size is equal to the number of parameters in
		// the Java source file, while it should generate an array whose size is
		// equal to the number of parameters in the method descriptor - which
		// includes the synthetic parameters added by the compiler). This work-
		// around supposes that the synthetic parameters are the first ones.
		int synthetics = Type.getArgumentTypes(desc).length - n;
		AnnotationVisitor av;
		for (i = 0; i < synthetics; ++i) {
			// virtual annotation to detect synthetic parameters in MethodWriter
			av = mv.visitParameterAnnotation(i, "Ljava/lang/Synthetic;", false);
			if (av != null) {
				av.visitEnd();
			}
		}
		for (; i < n + synthetics; ++i) {
			int j = readUnsignedShort(v);
			v += 2;
			for (; j > 0; --j) {
				av = mv.visitParameterAnnotation(i, readUTF8(v, buf), visible);
				v = readAnnotationValues(v + 2, buf, true, av);
			}
		}
	}

	/**
	 * Reads the values of an annotation and makes the given visitor visit them.
	 *
	 * @param v	 the start offset in {@link #b b} of the values to be read
	 *              (including the unsigned short that gives the number of values).
	 * @param buf   buffer to be used to call {@link #readUTF8 readUTF8},
	 *              {@link #readClass(int, char[]) readClass} or
	 *              {@link #readConst readConst}.
	 * @param named if the annotation values are named or not.
	 * @param av	the visitor that must visit the values.
	 * @return the end offset of the annotation values.
	 */
	private int readAnnotationValues(
			int v,
			final char[] buf,
			final boolean named,
			final AnnotationVisitor av) {
		int i = readUnsignedShort(v);
		v += 2;
		if (named) {
			for (; i > 0; --i) {
				v = readAnnotationValue(v + 2, buf, readUTF8(v, buf), av);
			}
		} else {
			for (; i > 0; --i) {
				v = readAnnotationValue(v, buf, null, av);
			}
		}
		if (av != null) {
			av.visitEnd();
		}
		return v;
	}

	/**
	 * Reads a value of an annotation and makes the given visitor visit it.
	 *
	 * @param v	the start offset in {@link #b b} of the value to be read (<i>not
	 *             including the value name constant pool index</i>).
	 * @param buf  buffer to be used to call {@link #readUTF8 readUTF8},
	 *             {@link #readClass(int, char[]) readClass} or
	 *             {@link #readConst readConst}.
	 * @param name the name of the value to be read.
	 * @param av   the visitor that must visit the value.
	 * @return the end offset of the annotation value.
	 */
	private int readAnnotationValue(
			int v,
			final char[] buf,
			final String name,
			final AnnotationVisitor av) {
		int i;
		if (av == null) {
			switch (b[v] & 0xFF) {
				case 'e': // enum_const_value
					return v + 5;
				case '@': // annotation_value
					return readAnnotationValues(v + 3, buf, true, null);
				case '[': // array_value
					return readAnnotationValues(v + 1, buf, false, null);
				default:
					return v + 3;
			}
		}
		switch (b[v++] & 0xFF) {
			case 'I': // pointer to CONSTANT_Integer
			case 'J': // pointer to CONSTANT_Long
			case 'F': // pointer to CONSTANT_Float
			case 'D': // pointer to CONSTANT_Double
				av.visit(name, readConst(readUnsignedShort(v), buf));
				v += 2;
				break;
			case 'B': // pointer to CONSTANT_Byte
				av.visit(name,
						new Byte((byte) readInt(items[readUnsignedShort(v)])));
				v += 2;
				break;
			case 'Z': // pointer to CONSTANT_Boolean
				av.visit(name, readInt(items[readUnsignedShort(v)]) == 0
						? Boolean.FALSE
						: Boolean.TRUE);
				v += 2;
				break;
			case 'S': // pointer to CONSTANT_Short
				av.visit(name,
						new Short((short) readInt(items[readUnsignedShort(v)])));
				v += 2;
				break;
			case 'C': // pointer to CONSTANT_Char
				av.visit(name,
						new Character((char) readInt(items[readUnsignedShort(v)])));
				v += 2;
				break;
			case 's': // pointer to CONSTANT_Utf8
				av.visit(name, readUTF8(v, buf));
				v += 2;
				break;
			case 'e': // enum_const_value
				av.visitEnum(name, readUTF8(v, buf), readUTF8(v + 2, buf));
				v += 4;
				break;
			case 'c': // class_info
				av.visit(name, Type.getType(readUTF8(v, buf)));
				v += 2;
				break;
			case '@': // annotation_value
				v = readAnnotationValues(v + 2,
						buf,
						true,
						av.visitAnnotation(name, readUTF8(v, buf)));
				break;
			case '[': // array_value
				int size = readUnsignedShort(v);
				v += 2;
				if (size == 0) {
					return readAnnotationValues(v - 2,
							buf,
							false,
							av.visitArray(name));
				}
				switch (this.b[v++] & 0xFF) {
					case 'B':
						byte[] bv = new byte[size];
						for (i = 0; i < size; i++) {
							bv[i] = (byte) readInt(items[readUnsignedShort(v)]);
							v += 3;
						}
						av.visit(name, bv);
						--v;
						break;
					case 'Z':
						boolean[] zv = new boolean[size];
						for (i = 0; i < size; i++) {
							zv[i] = readInt(items[readUnsignedShort(v)]) != 0;
							v += 3;
						}
						av.visit(name, zv);
						--v;
						break;
					case 'S':
						short[] sv = new short[size];
						for (i = 0; i < size; i++) {
							sv[i] = (short) readInt(items[readUnsignedShort(v)]);
							v += 3;
						}
						av.visit(name, sv);
						--v;
						break;
					case 'C':
						char[] cv = new char[size];
						for (i = 0; i < size; i++) {
							cv[i] = (char) readInt(items[readUnsignedShort(v)]);
							v += 3;
						}
						av.visit(name, cv);
						--v;
						break;
					case 'I':
						int[] iv = new int[size];
						for (i = 0; i < size; i++) {
							iv[i] = readInt(items[readUnsignedShort(v)]);
							v += 3;
						}
						av.visit(name, iv);
						--v;
						break;
					case 'J':
						long[] lv = new long[size];
						for (i = 0; i < size; i++) {
							lv[i] = readLong(items[readUnsignedShort(v)]);
							v += 3;
						}
						av.visit(name, lv);
						--v;
						break;
					case 'F':
						float[] fv = new float[size];
						for (i = 0; i < size; i++) {
							fv[i] = Float.intBitsToFloat(readInt(items[readUnsignedShort(v)]));
							v += 3;
						}
						av.visit(name, fv);
						--v;
						break;
					case 'D':
						double[] dv = new double[size];
						for (i = 0; i < size; i++) {
							dv[i] = Double.longBitsToDouble(readLong(items[readUnsignedShort(v)]));
							v += 3;
						}
						av.visit(name, dv);
						--v;
						break;
					default:
						v = readAnnotationValues(v - 3,
								buf,
								false,
								av.visitArray(name));
				}
		}
		return v;
	}

	private int readFrameType(
			final Object[] frame,
			final int index,
			int v,
			final char[] buf,
			final Label[] labels) {
		int type = b[v++] & 0xFF;
		switch (type) {
			case 0:
				frame[index] = Opcodes.TOP;
				break;
			case 1:
				frame[index] = Opcodes.INTEGER;
				break;
			case 2:
				frame[index] = Opcodes.FLOAT;
				break;
			case 3:
				frame[index] = Opcodes.DOUBLE;
				break;
			case 4:
				frame[index] = Opcodes.LONG;
				break;
			case 5:
				frame[index] = Opcodes.NULL;
				break;
			case 6:
				frame[index] = Opcodes.UNINITIALIZED_THIS;
				break;
			case 7: // Object
				frame[index] = readClass(v, buf);
				v += 2;
				break;
			default: // Uninitialized
				frame[index] = readLabel(readUnsignedShort(v), labels);
				v += 2;
		}
		return v;
	}

	/**
	 * Returns the label corresponding to the given offset. The default
	 * implementation of this method creates a label for the given offset if it
	 * has not been already created.
	 *
	 * @param offset a bytecode offset in a method.
	 * @param labels the already created labels, indexed by their offset. If a
	 *               label already exists for offset this method must not create a new
	 *               one. Otherwise it must store the new label in this array.
	 * @return a non null Label, which must be equal to labels[offset].
	 */
	protected Label readLabel(int offset, Label[] labels) {
		if (labels[offset] == null) {
			labels[offset] = new Label();
		}
		return labels[offset];
	}

	/**
	 * Reads an attribute in {@link #b b}.
	 *
	 * @param attrs   prototypes of the attributes that must be parsed during the
	 *                visit of the class. Any attribute whose type is not equal to the
	 *                type of one the prototypes is ignored (i.e. an empty
	 *                {@link Attribute} instance is returned).
	 * @param type	the type of the attribute.
	 * @param off	 index of the first byte of the attribute's content in
	 *                {@link #b b}. The 6 attribute header bytes, containing the type
	 *                and the length of the attribute, are not taken into account here
	 *                (they have already been read).
	 * @param len	 the length of the attribute's content.
	 * @param buf	 buffer to be used to call {@link #readUTF8 readUTF8},
	 *                {@link #readClass(int, char[]) readClass} or
	 *                {@link #readConst readConst}.
	 * @param codeOff index of the first byte of code's attribute content in
	 *                {@link #b b}, or -1 if the attribute to be read is not a code
	 *                attribute. The 6 attribute header bytes, containing the type and
	 *                the length of the attribute, are not taken into account here.
	 * @param labels  the labels of the method's code, or <tt>null</tt> if the
	 *                attribute to be read is not a code attribute.
	 * @return the attribute that has been read, or <tt>null</tt> to skip this
	 *         attribute.
	 */
	private Attribute readAttribute(
			final Attribute[] attrs,
			final String type,
			final int off,
			final int len,
			final char[] buf,
			final int codeOff,
			final Label[] labels) {
		for (int i = 0; i < attrs.length; ++i) {
			if (attrs[i].type.equals(type)) {
				return attrs[i].read(this, off, len, buf, codeOff, labels);
			}
		}
		return new Attribute(type).read(this, off, len, null, -1, null);
	}

	// ------------------------------------------------------------------------
	// Utility methods: low level parsing
	// ------------------------------------------------------------------------

	/**
	 * Returns the start index of the constant pool item in {@link #b b}, plus
	 * one. <i>This method is intended for {@link Attribute} sub classes, and is
	 * normally not needed by class generators or adapters.</i>
	 *
	 * @param item the index a constant pool item.
	 * @return the start index of the constant pool item in {@link #b b}, plus
	 *         one.
	 */
	public int getItem(final int item) {
		return items[item];
	}

	/**
	 * Reads a byte value in {@link #b b}. <i>This method is intended for
	 * {@link Attribute} sub classes, and is normally not needed by class
	 * generators or adapters.</i>
	 *
	 * @param index the start index of the value to be read in {@link #b b}.
	 * @return the read value.
	 */
	public int readByte(final int index) {
		return b[index] & 0xFF;
	}

	/**
	 * Reads an unsigned short value in {@link #b b}. <i>This method is
	 * intended for {@link Attribute} sub classes, and is normally not needed by
	 * class generators or adapters.</i>
	 *
	 * @param index the start index of the value to be read in {@link #b b}.
	 * @return the read value.
	 */
	public int readUnsignedShort(final int index) {
		byte[] b = this.b;
		return ((b[index] & 0xFF) << 8) | (b[index + 1] & 0xFF);
	}

	/**
	 * Reads a signed short value in {@link #b b}. <i>This method is intended
	 * for {@link Attribute} sub classes, and is normally not needed by class
	 * generators or adapters.</i>
	 *
	 * @param index the start index of the value to be read in {@link #b b}.
	 * @return the read value.
	 */
	public short readShort(final int index) {
		byte[] b = this.b;
		return (short) (((b[index] & 0xFF) << 8) | (b[index + 1] & 0xFF));
	}

	/**
	 * Reads a signed int value in {@link #b b}. <i>This method is intended for
	 * {@link Attribute} sub classes, and is normally not needed by class
	 * generators or adapters.</i>
	 *
	 * @param index the start index of the value to be read in {@link #b b}.
	 * @return the read value.
	 */
	public int readInt(final int index) {
		byte[] b = this.b;
		return ((b[index] & 0xFF) << 24) | ((b[index + 1] & 0xFF) << 16)
				| ((b[index + 2] & 0xFF) << 8) | (b[index + 3] & 0xFF);
	}

	/**
	 * Reads a signed long value in {@link #b b}. <i>This method is intended
	 * for {@link Attribute} sub classes, and is normally not needed by class
	 * generators or adapters.</i>
	 *
	 * @param index the start index of the value to be read in {@link #b b}.
	 * @return the read value.
	 */
	public long readLong(final int index) {
		long l1 = readInt(index);
		long l0 = readInt(index + 4) & 0xFFFFFFFFL;
		return (l1 << 32) | l0;
	}

	/**
	 * Reads an UTF8 string constant pool item in {@link #b b}. <i>This method
	 * is intended for {@link Attribute} sub classes, and is normally not needed
	 * by class generators or adapters.</i>
	 *
	 * @param index the start index of an unsigned short value in {@link #b b},
	 *              whose value is the index of an UTF8 constant pool item.
	 * @param buf   buffer to be used to read the item. This buffer must be
	 *              sufficiently large. It is not automatically resized.
	 * @return the String corresponding to the specified UTF8 item.
	 */
	public String readUTF8(int index, final char[] buf) {
		int item = readUnsignedShort(index);
		String s = strings[item];
		if (s != null) {
			return s;
		}
		index = items[item];
		return strings[item] = readUTF(index + 2, readUnsignedShort(index), buf);
	}

	/**
	 * Reads UTF8 string in {@link #b b}.
	 *
	 * @param index  start offset of the UTF8 string to be read.
	 * @param utfLen length of the UTF8 string to be read.
	 * @param buf	buffer to be used to read the string. This buffer must be
	 *               sufficiently large. It is not automatically resized.
	 * @return the String corresponding to the specified UTF8 string.
	 */
	private String readUTF(int index, final int utfLen, final char[] buf) {
		int endIndex = index + utfLen;
		byte[] b = this.b;
		int strLen = 0;
		int c;
		int st = 0;
		char cc = 0;
		while (index < endIndex) {
			c = b[index++];
			switch (st) {
				case 0:
					c = c & 0xFF;
					if (c < 0x80) {  // 0xxxxxxx
						buf[strLen++] = (char) c;
					} else if (c < 0xE0 && c > 0xBF) {  // 110x xxxx 10xx xxxx
						cc = (char) (c & 0x1F);
						st = 1;
					} else {  // 1110 xxxx 10xx xxxx 10xx xxxx
						cc = (char) (c & 0x0F);
						st = 2;
					}
					break;

				case 1:  // byte 2 of 2-byte char or byte 3 of 3-byte char
					buf[strLen++] = (char) ((cc << 6) | (c & 0x3F));
					st = 0;
					break;

				case 2:  // byte 2 of 3-byte char
					cc = (char) ((cc << 6) | (c & 0x3F));
					st = 1;
					break;
			}
		}
		return new String(buf, 0, strLen);
	}

	/**
	 * Reads a class constant pool item in {@link #b b}. <i>This method is
	 * intended for {@link Attribute} sub classes, and is normally not needed by
	 * class generators or adapters.</i>
	 *
	 * @param index the start index of an unsigned short value in {@link #b b},
	 *              whose value is the index of a class constant pool item.
	 * @param buf   buffer to be used to read the item. This buffer must be
	 *              sufficiently large. It is not automatically resized.
	 * @return the String corresponding to the specified class item.
	 */
	public String readClass(final int index, final char[] buf) {
		// computes the start index of the CONSTANT_Class item in b
		// and reads the CONSTANT_Utf8 item designated by
		// the first two bytes of this CONSTANT_Class item
		return readUTF8(items[readUnsignedShort(index)], buf);
	}

	/**
	 * Reads a numeric or string constant pool item in {@link #b b}. <i>This
	 * method is intended for {@link Attribute} sub classes, and is normally not
	 * needed by class generators or adapters.</i>
	 *
	 * @param item the index of a constant pool item.
	 * @param buf  buffer to be used to read the item. This buffer must be
	 *             sufficiently large. It is not automatically resized.
	 * @return the {@link Integer}, {@link Float}, {@link Long},
	 *         {@link Double}, {@link String} or {@link Type} corresponding to
	 *         the given constant pool item.
	 */
	public Object readConst(final int item, final char[] buf) {
		int index = items[item];
		switch (b[index - 1]) {
			case ClassWriter.INT:
				return new Integer(readInt(index));
			case ClassWriter.FLOAT:
				return new Float(Float.intBitsToFloat(readInt(index)));
			case ClassWriter.LONG:
				return new Long(readLong(index));
			case ClassWriter.DOUBLE:
				return new Double(Double.longBitsToDouble(readLong(index)));
			case ClassWriter.CLASS:
				return Type.getObjectType(readUTF8(index, buf));
			// case ClassWriter.STR:
			default:
				return readUTF8(index, buf);
		}
	}
}
